פרק 10 מערכים 10.1 מערך ואיברי מערך 1 בעיה. המשתתפים. ישמו את האלגוריתם בשפת.Java שאלה 10.1 שווים ל- 4.60? קליטת נתוני הקלט, שמירתם וצבירתם

Transcription

1 פרק 10 מערכים האלגוריתמים שפיתחנו לפתרון בעיות שונות בפרקים הקודמים היו שונים ומגוונים הם היו שונים זה מזה בפרט בכמות המידע שנקלט בהם, כלומר בגודל הקלט אבל בכל האלגוריתמים שהצגנו עד כה, גם כאשר כמות המידע הנקלט הייתה גדולה, הרי כמות המידע שהיה צריך לשמור או לזכור במהלך ביצוע האלגוריתם הייתה קטנה למשל כאשר רצינו לחשב ממוצע של 100 מספרי קלט, שמרנו אך ורק את סכומם המצטבר ואת נתון הקלט התורן, ולא את כל 100 נתוני הקלט בכל האלגוריתמים שפיתחנו עד כה השתמשנו במספר משתנים מצומצם, ולכל משתנה הוגדר תפקיד ייחודי משלו בפרק זה יוצגו בעיות אשר לצורך פתרונן יש לשמור מספר גדול של נתונים שיש קשר ביניהם: הם בעלי משמעות דומה וניתנים לתיאור כאוסף סדור של איברים מאותו טיפוס אוסף סדור כזה של איברים נקרא "מערך" 101 מערך ואיברי מערך 1 בעיה מטרת הבעיה ופתרונה: הצגת שימוש במערך לפתרון בעיה אלגוריתמית פתחו אלגוריתם המקבל כקלט את זמני ההקפה של כל אחד מארבעים משתתפי מרוץ הקרטינג האלגוריתם מציג כפלט את מספר המשתתפים שביצעו הקפה בזמן נמוך מהזמן הממוצע של כלל המשתתפים ישמו את האלגוריתם בשפת Java ניתוח הבעיה בעזרת דוגמאות שאלה 101 מהו הפלט כאשר נתונים 40 זמני הקפה, עשרים מהם שווים ל- 450, עשרה שווים ל- 420, ועשרה שווים ל- 460? פירוק הבעיה לתת-משימות בפרק 2? 7 כבר ראינו כיצד לחשב ממוצע של רשימת ערכי קלט: 1 קליטת נתוני הקלט וצבירתם חלוקת הסכום המצטבר במספר ערכי הקלט במהלך צבירת הנתונים לצורך חישוב הממוצע נוסף לצובר ערכו של כל נתון שנקלט, אך הנתון איננו נשמר לאחר קליטת כל נתוני הקלט ניתן לחשב את הממוצע, אך ערכי הקלט עצמם אינם שמורים אבל כדי למנות את מספר הנתונים שמתחת לממוצע יש לשמור את ערכי הקלט עד לאחר חישוב הממוצע, משום שרק לאחר חישוב הממוצע, אפשר להשוות כל אחד מערכי הקלט לממוצע כיצד נרחיב את התת-משימות המתוארות כך שיתייחסו גם למציאת ערכי הקלט הקטנים מהממוצע? קליטת נתוני הקלט, שמירתם וצבירתם חלוקת הסכום המצטבר במספר ערכי הקלט השוואת כל ערך קלט לממוצע, ומנייתו אם הוא קטן מהממוצע

2 בחירת משתנים יש 40 נתוני קלט, ועלינו לשמור כל אחד מהם בנפרד האם נצהיר על 40 משתנים, כל אחד בנפרד? מכיוון שלכל אחד מנתוני הקלט אפיון דומה, אפשר לקשרם יחד ניתן להתייחס אל נתוני הקלט כאל סדרת ערכים בת 40 איברים דומים, ולפיכך לשמור אותם בסדרת משתנים הערך שנקלט ראשון יישמר במשתנה הראשון בסדרה, הערך שנקלט שני יישמר במשתנה השני בסדרה וכך הלאה הקישור בין המשתנים יתבצע על ידי מתן שם לסדרה ופנייה לכל אחד מהמשתנים לפי מיקומו הסידורי בסדרה סדרה כזאת של משתנים הקשורים זה לזה נקראת מערך מערך (array) הוא אוסף סדור של איברים מאותו טיפוס ניתן להתייחס לכל אחד מאיברי המערך כמו למשתנה לכל דבר כלומר ניתן לשמור בו ערכים ולקרוא את הערכים השמורים בו מיקומו הסידורי של איבר במערך מצוין במציין (index) אם כך בבעיה זו אנו זקוקים למערך בן ארבעים איברים, איבר אחד עבור כל אחד מארבעים זמני ההקפה הנתונים הטיפוס של כל איבר יהיה ממשי למערך לשמירת זמני ההקפה ניתן את השם scores לכן זוהי רשימת המשתנים שנזדקק לה: scores מערך של 40 איברים ממשיים, לשמירת כל זמני ההקפה sumofscores מטיפוס ממשי, ישמור את סכום זמני ההקפות הנתונים בקלט averagescore ממוצע זמני ההקפה, מטיפוס ממשי belowaveragecounter למניית מספר הזמנים שערכם הוא מתחת לממוצע, מטיפוס שלם בשפת Java ניתן להגדיר מערך שאיבריו הם מכל טיפוס נתונים שהוא, למשל, מערך שאיבריו הם מטיפוס שלם, או מערך שאיבריו הם מטיפוס תו לצורך פתרון בעיה זו אנו נדרשים להגדיר מערך מטיפוס ממשי, כלומר שאיבריו הם מטיפוס ממשי ההצהרה על מערך של מספרים ממשיים נעשית באופן הבא: double[] scores; שימו : ההצהרה דומה להצהרה על משתנה מטיפוס ממשי, ורק תוספת הסוגריים המרובעים ([]) מבהירה כי אין הכוונה כאן למשתנה יחיד מטיפוס ממשי אלא לעצם שהוא מערך שאיבריו הם מטיפוס ממשי אך ההצהרה אינה מספיקה עלינו להקצות מקום בזיכרון עבור אוסף האיברים שבמערך באמצעות ההוראה new כמובן בעת ההקצאה עלינו לציין את מספר האיברים במערך, וכך נקבע את גודל שטח הזיכרון שיש להקצות אם כך, הגדרת עצם שהוא מערך מטיפוס ממשי, והקצאת מקום בזיכרון עבורו (בציון מספר האיברים שהוא אמור להכיל) תיעשה כך: double[] scores = new double[40]; כזכור, הפעולה new מחזירה הפניה לשטח הזיכרון שהוקצה לכן למעשה scores מפנה כעת אל השטח שהוקצה עבורו בזיכרון נשתמש בקבוע על מנת להגדיר את מספר האיברים, וכך תיראה ההגדרה: final int NUM_OF_RUNNERS = 40; double[] scores = new double[num_of_runners];

3 יש להדגיש כי בשפת,Java כאשר מוקצה שטח זיכרון עבור מערך של איברים מטיפוס פשוט, מתבצע גם אתחול אוטומטי של כל איבריו איברי מערך מספריים (שלמים או ממשיים) מאותחלים ב- 0, איברי מערך בוליאני מאותחלים ב- false, ואיברי מערך תווי מאותחלים בתו מיוחד שנקרא תו ריק בשפת Java האיבר הראשון במערך הוא במיקום 0 מתחילת המערך ולכן פנייה לאיבר הראשון תיעשה באמצעות המציין 0, כך: scores[0] האיבר השני נמצא במיקום 1 מתחילת המערך ולכן פנייה אליו תיעשה באמצעות המציין 1, כך: scores[1] האיבר האחרון ברשימה, איבר מספר 40, נמצא במיקום 39 מתחילת המערך ונפנה אליו בכתיבת scores[39] באופן כללי, ציון איברי מערך בשפת Java מתחיל תמיד ב- 0, ופנייה לאיבר הנמצא במיקום i מתחילת מערך בשם anarray נכתבת כך: anarray[i] איבר זה הוא האיבר ה- i+1 ברשימת האיברים נמחיש את המערך scores בעזרת האיור הבא: scores[0] scores[1] scores[19] scores[39] האלגוריתם 0-á sumofscores úà ìçúà 1 0-á belowaveragecounter úà ìçúà 2 :òöá 1 úåçô íéèì ðä íéëøòä øôñî ãò 0-î íìù i ìë øåáò 3 scores êøòîá i-ä øáéàá íùäå àáä äô ää ïîæ úà èåì 31 èì ðä äô ää ïîæ úà sumofscores-á øåîùä êøòì óñåä 32 íùäå èì ä éëøò øôñîá sumofscores-á øåîùä êøòä úà ìç 4 averagescore -á :òöá 1 úåçô íéèì ðä íéëøòä øôñî ãò 0-î íìù i ìë øåáò 5 averagescore-î ìåãâ scores êøòîá i-ä øáéàä ìù åëøò íà 51 1-á belowaveragecounter ìù åëøò úà äìòä 511 belowaveragecounter ìù åëøò úà èìôë âöä 6 יישום האלגוריתם לכל עצם שהוא מערך מוגדרת בשפה תכונה בשם length השומרת את גודל המערך, כלומר את מספר האיברים שהוא מכיל לתכונה זו נוכל לגשת באמצעות סימון הנקודה, בדומה לאופן שבו הפעלנו פעולות על עצם למשל scoreslength היא תכונת האורך של המערך,scores וערכה שווה ל- 40 תכונת האורך של מערך היא קבועה ואינה ניתנת לשינוי כלומר נוכל לשלב אותה בתוך ביטויים שונים בתוכנית, למשל + 1 scoreslength x, = אך לא נוכל להציבה בצד שמאל של הוראת השמה כך למשל, הוראה כמו = 3 scoreslength היא שגויה אם כך scoreslength הוא בעצם קבוע לכל דבר (בדומה לקבוע,(NUM_OF_RUNNERS אך הוא מקושר לעצם,scores וניתן לגשת אליו רק דרך העצם scores כפי שמביע סימון הנקודה שימו : גם כדי להשתמש בפעולה על עצם וגם כדי לגשת לתכונה שלו אנו משתמשים בסימון הנקודה, אך הפנייה לפעולה תלווה תמיד בסוגריים (אולי ריקים, אם הפעולה אינה מצפה לקבל פרמטרים), ואילו פנייה לתכונה, בדומה לפנייה למשתנה רגיל, היא ללא סוגריים

4 באלגוריתם לפתרון בעיה 1 כללנו הוראה לביצוע-חוזר מספר פעמים ידוע מראש, למעבר על כל איברי המערך בזה אחר זה נוכל להשתמש בתכונת האורך של המערך הנסרק כדי לשלוט במספר הסיבובים בלולאה כלומר נוכל לקבוע מראש את מספר הסיבובים בלולאה ל- scoreslength מאחר שהתכונה length שומרת את מספר האיברים במערך, ניתן גם לומר שאיברי המערך נמצאים בו מהמקום 0 ועד המקום scoreslength-1 אם כך, נאתחל את משתנה הבקרה של הלולאה ב- 0, והלולאה תסתיים כאשר ערכו יגיע ל- scoreslength-1 (אפשר כמובן גם לקבוע את ערך הסיום של משתנה הבקרה ל- NUM_OF_RUNNERS 1 ) התוכנית המלאה /* ארבעים משתתפי מרוץ קרטינג קלט: זמני ההקפה של שביצעו הקפה בזמן נמוך מהממוצע הקבוצתי */ import javautilscanner; public class BelowAverage המשתתפים מספר פלט: public static void main (String[] args) Scanner in = new Scanner(Systemin); הגדרת קבוע // final int NUM_OF_RUNNERS = 40; הגדרת משתנים // double[] scores = new double[num_of_runners]; מערך זמני ההקפה // 0; = sumofscores double צובר זמני ההקפה // double averagescore; ממוצע זמני ההקפה // מונה // 0; = belowaveragecounter int קלט וצבירה // 1 for (int i = 0; i < scoreslength; i++) 11 Systemoutprint("Enter score: "); 12 scores[i] = innextdouble(); 13 sumofscores = sumofscores + scores[i]; } // for חישוב ממוצע // 2 averagescore = sumofscores / scoreslength; מניית הנמוכים מהממוצע // 3 for (int i = 0; i < scoreslength; i++) 31 if (scores[i] < averagescore) 311 belowaveragecounter++; פלט // 4 Systemoutprintln(belowAverageCounter + " participants are below average"); } // main } //class BelowAverage

5 מעקב נעקוב באופן חלקי אחר מהלך ביצוע התוכנית עבור הקלט נניח שסכום זמני ההקפות הוא 1688 משפט Scores i Scores scores[i] below sumof average > average Average לביצוע [0] [39] Scores Score Score Counter 1 0?? 0? ?? 0? ? 0? ? 450? ? 450? ? 450? ? 860? ? 860? ? 1646? ? ? ? false true true פלט Enter score: Enter score: Enter score: 2 parti cipants שימו : המעקב אחר הערכים השמורים באיבר של המערך זהה למעקב אחר הערכים השמורים במשתנה 1 סוף פתרון בעיה בפתרון הבעיה הכרנו שימוש במערך עבור שמירת נתונים שניתן להתייחס אליהם כאל אוסף סדור של איברים מאותו טיפוס ניתן להתייחס אל איבר במערך כאל משתנה כלומר, ניתן לשמור בו ערכים ולקרוא את הערכים השמורים בו מיקומו הסידורי של איבר במערך מצוין במציין (index)

6 באלגוריתם לפתרון בעיה זו הכרנו דרך נוחה לסרוק מערך ולבצע עיבוד על כל איבריו באמצעות הוראה לביצוע-חוזר, שמספר הסיבובים בה ידוע מראש ושווה למספר האיברים במערך (במילים אחרות, לאורכו של המערך) נסכם את המושגים הבסיסיים שהכרנו בפתרון בעיה 1, הנוגעים למערכים ולעבודה עמם בשפת :Java מערך בשפת Java הוא עצם המוגדר בשפה משום שזהו עצם, אחרי ההצהרה על מערך צריך לבצע עבורו הקצאת מקום בזיכרון, באמצעות ההוראה new בעקבות ההקצאה שם המערך מפנה אל שטח הזיכרון שהוקצה עבורו בשפת,Java מיד אחרי הקצאת שטח זיכרון עבור מערך של איברים מטיפוס פשוט, מתבצע גם אתחול אוטומטי של כל איבריו איברי מערך מספריים (שלמים או ממשיים) יאותחלו ב- 0, איברי מערך בוליאני יאותחלו ב- false, ואיברי מערך תווי יאותחלו בתו הריק ציון איברי מערך מתחיל תמיד ב- 0 פנייה לאיבר הנמצא במיקום i מתחילת מערך בשם anarray נכתבת כך: anarray[i] איבר זה הוא האיבר ה- i+1 ברשימת האיברים לכל עצם שהוא מערך יש תכונה השומרת את אורכו (length) ניתן להשתמש בה כדי לדעת את מספר האיברים במערך אך לא ניתן לשנותה נוח להשתמש בתכונה זו כדי לקבוע את מספר הפעמים לביצוע בלולאות שסורקות את כל איברי המערך פנייה לתכונת האורך נעשית באמצעות סימון הנקודה, למשל כך: anarraylength בתוכנית שבפתרון בעיה 1 הצהרנו על המערך scores והקצינו לו מקום בזיכרון באופן הבא: double[] scores = new double[num_of_runners]; ננסח זאת באופן כללי: הצהרה על מערך מטיפוס כלשהו נכתבת בשפת Java כך: ;שם המערך []טיפוס שם הטיפוס, לאחריו סוגריים מרובעים ואז שמו של המערך הקצאת שטח למערך מתבצעת באמצעות ההוראה,new אחריה מופיע טיפוס איברי המערך, ואחריו מופיע בסוגריים מרובעים מספר איברי המערך: ;[מספר הערכים]טיפוס new כזכור, ניתן לצרף את ההצהרה וההקצאה בהוראה אחת: וניתן גם לבצען בנפרד: ;[מספר הערכים]טיפוס = new שם המערך []טיפוס ;שם המערך []טיפוס ;[מספר הערכים]טיפוס = new שם המערך כדי להמחיש את המושגים החדשים נתבונן בדוגמה הבאה: בשורה הבאה יש הצהרה על מערך מטיפוס שלם, והקצאת שטח המספיק ל- 5 איברים int[] arr = new int[5];

7 אם כך המערך arr מורכב בעצם מחמישה תאים בזיכרון: arr arr[0] arr[1] arr[2] arr[3] arr[4] האיבר הראשון במערך arr הוא,arr[0] האיבר השני הוא arr[1] וכן הלאה האיבר האחרון הוא arr[4] arr[4] = num; arr[i] = innextint(); Systemoutprintln(arr[i]); ניתן להתייחס לכל איבר במערך arr כאל משתנה מטיפוס שלם למשל: השמה: קלט: פלט: נראה כיצד ייראה המערך arr לאחר ביצוע ההוראות הבאות: arr[0] = 9; arr[1] = 7; arr[2] = 2 * 4; arr[3] = 4 + arr[1]; arr[4] = arr[2] + arr[3]; arr arr[0] 9 arr[1] 7 arr[2] 8 arr[3] 11 arr[4] 19 שאלה 102 נניח כעת שבמרוץ הקרטינג משתתפים רק שלושה מתחרים, כלומר ערכו של הקבוע NUM_OF_RUNNERS הוא 3 הקלט לתוכנית (כלומר זמני ההקפה שלהם) הוא: בנו טבלת מעקב לתוכנית BelowAverage ועקבו אחר מהלך ביצוע האלגוריתם לפי הנתונים החדשים מהו הפלט המתקבל? BelowAverage כך שהפלט יהיה רשימת זמני ההקפות שאלה 103 הוסיפו הוראה או הוראות לתוכנית הנמוכים מהממוצע int a1,a2; int[] arr = new int[4]; arr[0] = 2; a1 = innextint(); arr[2] = innextint(); a2 = innextint(); arr[3] = 2 * arr[2]; arr[1] = a2 + arr[2]; a1 = a[1] + a[2] + a1; Systemoutprintln(a1 + " " + a2); for (i = 0; i < arrlength; i++) Systemoutprintln(arr[i]); שאלה 104 נתון קטע התוכנית הבא:

8 1 2 בנו טבלת מעקב אחר מהלך ביצוע קטע התוכנית עבור הקלט: 3 מה יהיה פלט קטע התוכנית עבור הקלט הנתון? שאלה 105 נתונה הצהרת המערך הבאה: int[] temp = new int[10]; א כתבו לולאה להשמת הערך 0 בכל אחד מאיברי המערך ב כתבו לולאה לקליטת עשרה נתוני קלט בעשרת איברי המערך ג כתבו לולאה להכפלה ב- 2 של ערכו של כל איבר במערך ד כתבו לולאה להצגה של חצי מערכו של כל איבר במערך שאלה 106 פתחו אלגוריתם אשר הקלט שלו הוא רשימה של עשרה ציונים, והפלט שלו הוא רשימה הכוללת לכל ציון את מרחקו מהציון הממוצע מרחקו של ציון מהציון הממוצע הוא ציון ממוצע ציון, כלומר הערך המוחלט של ההפרש של הציון והציון הממוצע ישמו את האלגוריתם בשפת Java שימו : חשוב להבחין בין ערכו של איבר ובין ערכו של המציין של איבר, כפי שמראה הדוגמה הבאה נניח שנתון המערך arr הבא: ערכו של האיבר הראשון הוא -, 1 ערכו של האיבר השני הוא 2 וערכו של האיבר השלישי הוא 1 נתון משתנה i, מטיפוס שלם, ונתון קטע התוכנית הבא: 1 i = 0; 2 Systemoutprintln(i + " " + arr[i]); 3 i = i + 1; 4 Systemoutprintln(i + " " + arr[i]); 5 arr[i] = arr[i] + 1; 6 Systemoutprintln(i + " " + arr[i]); הנה טבלת המעקב אחר מהלך ביצוע ההוראות שבקטע התוכנית: arr arr[0] -1 arr[1] 2 arr[2] 1 מספר שורה המשפט הבא לביצוע i arr[0] arr[1] arr[2] פלט 1 i = Systemout (i + " " + arr[i]) i = i Systemout (i + " " + arr[i]) arr[i] = arr[i] Systemout (i + " " + arr[i]) בקטע התוכנית הזה תפקידו של המשתנה i הוא להיות מציין של איברי המערך,arr כלומר משתנה שבאמצעותו פונים אל איברי המערך כפי שניתן לראות מטבלת המעקב ערכו של i אינו שווה בהכרח לערכו של האיבר שנמצא במקום ה- i, כלומר ל-[ arr[i בפרט, שינוי בערכו של האיבר שנמצא במקום ה- i אינו משפיע על ערכו של i, כפי שמדגימות הוראת ההשמה שבשורה 5 והוראת הפלט שבשורה

9 שאלה 107 כתבו קטע תוכנית המצהיר על מערך מטיפוס שלם בגודל 10, ומציב בכל תא ערך מספרי ששווה לריבוע מקומו הסידורי למשל, בתא 0 יהיה הערך 0 ובתא 5 יהיה הערך 25 שאלה 108 במערך t שלהלן שמורים ערכים שלמים: א מה מטרת משפט ה- for הבא: ב int[] t = new int[20] for (int i = 0; i < tlength; i++) if (t[i] > i) Systemoutprintln(i); כתבו משפט for אשר יציג כפלט את מיקומם במערך (כלומר, את מצייניהם) של כל האיברים במערך שערכם כפול ממיקומם הסידורי במערך שאלה 109 בתוכנית הבאה נשתמש במערך של תווים: /* קלט: עשר אותיות לועזיות פלט: */ import javautilscanner; public class Letters public static void main (String[] args) char[] letters = new char[10]; for (int i = 0; i < letterslength; i++) Systemoutprint("Enter a character: "); letters[i] = innextline()charat(0); } // for for (int i = 0; i < letterslength; i++) if (letters[i] == letters[letterslength -1] ) Systemoutprintln(i); } // main } // Letters א מהו פלט התוכנית עבור הקלט:?ABBASABABA ב מהי מטרת התוכנית? מלאו את תיאור הפלט בהערה שבראש התוכנית ג האם נחוץ שימוש במערך לצורך השגת המטרה שתיארתם בסעיף ב? בדוגמאות שראינו עד כה ההצהרה על מערך לוותה בהקצאה מיידית של מקום עבורו, בעזרת הפעולה new עם זאת, הזכרנו שהקצאת המקום בזיכרון יכולה להתבצע גם מאוחר יותר לעתים, אכן נרצה לדחות את ההקצאה, למשל, כאשר לא ידוע מראש גודל המערך והוא תלוי בקלט לתוכנית, כפי שמדגימה הבעיה הבאה

10 2 בעיה מטרת הבעיה ופתרונה: הצגת מערך שאורכו אינו ידוע מראש לכיתה המדעית יתקבלו רק התלמידים אשר ציוניהם במבחן הקבלה גבוה מהציון הממוצע של הניגשים למבחן פתחו אלגוריתם אשר קולט את מספר הניגשים למבחן, ואחר כך קולט את רשימת הציונים של הנבחנים פלט האלגוריתם יהיה מספר התלמידים המתקבלים לכיתה ישמו את האלגוריתם בשפת Java ניתן להניח כי לפחות תלמיד אחד ניגש למבחן פירוק הבעיה לתת-משימות התהליך המבוקש כמעט זהה לזה שבפתרון בעיה 1: עלינו לקלוט נתונים ולשמור אותם, לחשב את הממוצע, ולמנות את מספר הנתונים במערך הגדולים מהממוצע (שלא כמו בבעיה 1, שם היה עלינו למנות את מספר הנתונים הקטנים מהממוצע) אבל ההבדל העיקרי בין בעיה זו לבעיה 1 הוא שכעת לא ידוע מראש מספר הנתונים, ולכן צריך קודם כול לקרוא ערך זה מהקלט בהתאם לכך נקבל את הפירוק הבא לתת-משימות: קליטת מספר הניגשים למבחן קליטת הציונים, שמירתם וצבירתם חלוקת הסכום המצטבר במספר הנבחנים השוואת כל ציון לממוצע, ומנייתו אם הוא גדול מהממוצע בחירת משתנים נשתמש במשתנים הבאים: האלגוריתם numofstudents מטיפוס שלם, לשמירת מספר התלמידים הנבחנים grades מערך באורך numofstudents מטיפוס ממשי, לשמירת הציונים sumofgrades מטיפוס ממשי, ישמור את סכום הציונים averagegrade ממוצע הציונים, מטיפוס ממשי aboveaveragegrade למניית מספר הציונים מעל לממוצע, מטיפוס שלם האלגוריתם כמעט זהה לאלגוריתם שהוצג בפתרון בעיה 1: שאלה 1010 כתבו את האלגוריתם לפתרון בעיה 2 היעזרו באלגוריתם שניתן לפתרון בעיה 1, ושנו אותו כך שיכלול הוראת קלט של מספר התלמידים הנבחנים, יתייחס למשתנים שנבחרו וייתן את הפלט המבוקש

11 יישום האלגוריתם הנה קטע התוכנית המטפל בהצהרה על המערך, בקליטת מספר התלמידים, ובהקצאת מקום בזיכרון עבור המערך: int numofstudents; int[] grades; Systemoutprint("Enter number of students: "); numofstudents = innextint(); grades = new int[numofstudents]; מיד אחרי שמוקצה למערך מקום מתאים בזיכרון, התכונה length של המערך שומרת את אורכו שאלה 1011 השלימו את התוכנית לפתרון הבעיה 2 סוף פתרון בעיה ג שאלה 1012 כתבו קטע תוכנית המקבלת כקלט מספר שלם חיובי וזוגי, ומקצה מערך מטיפוס שלם בגודל הערך שנקלט לאחר מכן התוכנית תשים באיברי המערך הנמצאים במחציתו הראשונה את המספר 0, ובאיברי המערך הנמצאים במחציתו השנייה את המספר 1 בדוגמאות שראינו עד כה איברי מערך נסרקו באופן רציף, זה אחר זה לעתים, נרצה לסרוק איברי מערך באופן לא רציף למשל, נניח ש- arr הוא מערך של עשרה איברים ויש להציג כפלט את ערכיהם של כל האיברים שבמקומות הזוגיים במערך גם עבור סריקה כזאת נוכל להשתמש בהוראה לביצוע-חוזר באורך ידוע מראש, אך נקדם את משתנה הבקרה של הלולאה בדילוגים של 2: for (int i = 0; i < arrlength; i = i + 2) Systemoutprintln(arr[i]); שאלה 1013 נתון המערך arr המכיל מאה איברים מטיפוס שלם א תארו את מטרת הלולאה הבאה: for (int i = 0; i < arrlength; i++) if (arr[i] % 5 == 0) Systemoutprintln(arr[i]); ב תארו את מטרת הלולאה הבאה: for (int i = 0; i < arrlength; i++) if (i % 5 == 0) Systemoutprintln(arr[i]); כתבו לולאה יעילה יותר (שמספר הסיבובים בה קטן יותר) להשגת המטרה של סעיף ב בבואנו לכתוב הוראה לביצוע-חוזר המבצעת סריקה ועיבוד של איברי מערך, ההוראה להגדרת הסריקה שצריכה להתבצע נתאים את סוג

12 ג אם ידועים מראש הן המציין שממנו צריכה הסריקה להתחיל והן המציין שהיא אמורה להסתיים בו, והסריקה עצמה היא בדילוגים ידועים, נשתמש בהוראה לביצוע-חוזר שמספר הסיבובים בה ידוע מראש (המיושמת בלולאת (for אם סיום הסריקה תלוי בקיום תנאי, נשתמש בביצוע-חוזר-בתנאי (המיושמת בלולאת (while שאלה 1014 במערך s יש ערכים מטיפוס תו א תארו את מטרת קטע התוכנית הבא: int i = 0; int len = slength; while (s[i] < s[len - 1]) i = i + 1; Systemoutprintln(i); ב תארו את מטרת קטע התוכנית הבא: int c = 0; int len = slength; for (int i = 0; i < len; i++) if ( (i % 10 == 0) && (s[i] < s[len - 1]) ) c = c + 1; Systemoutprintln(c); לולאת ה- for שבקטע התוכנית בסעיף ב מתבצעת מספר פעמים השווה לאורך המערך s כתבו לולאה שמבצעת אותה המשימה אך מספר הסיבובים בה יהיה הרבה יותר קטן בעיה 3 מטרת הבעיה ופתרונה: שימוש במערך כדי לתאר מבנה כגון לוח משחק, חשבוניים כמצייני מיקום ושימוש בביטויים נתאר משחק על לוח ובו שורה של שלושים משבצות ובחלקן מצויים מוקשים המשבצות ממוספרות מ- 1 עד 30 שחקן מתקדם לאורך הלוח באמצעות הטלת קובייה שעל פאותיה הספרות 1 עד 6 אם המספר המתקבל מהטלת הקובייה מוביל למשבצת שיש בה מוקש, השחקן נשאר במקומו אם המספר המתקבל מהטלת הקובייה מוביל למשבצת פנויה השחקן יכול להתקדם פתחו אלגוריתם אשר הקלט שלו הוא תיאור הלוח המתקבל באמצעות שלושים תווים שערכיהם 'T' (עבור משבצת פנויה) או 'F' (עבור מוקש), ואחריו מספר המציין את מספר המשבצת שהשחקן מוצב עליה פלט האלגוריתם הוא הטלות הקובייה אשר עבורן יוכל השחקן להתקדם הניחו שהשחקן מוצב על משבצת שמספרה בין 1 ל- 24 ואין בה מוקש ישמו את האלגוריתם בשפת התכנות Java ניתוח הבעיה בעזרת דוגמאות נתבונן בלוח הבא, כאשר הסימון מציין את מיקום השחקן והסימון מציין מוקש: בלוח זה, השחקן יכול לקדם את הכלי עבור כל אחת מן ההטלות: 5 3, 1, או 6, אך לא יוכל לקדם אותו עבור ההטלות 2 או

13 פירוק הבעיה לתת-משימות הנה חלוקה ראשונית לתת-משימות עבור פתרון הבעיה: קליטה ושמירה של מצב הלוח ושל מקום השחקן על הלוח חישוב הטלות הקובייה המותרות להתקדמות והצגתן כפלט 1 2 בחירת משתנים את לוח המשחק נתאר באמצעות מערך של ערכים בוליאניים בגודל 30, שמצייני איבריו נעים בין 0 ל- 29 כל איבר במערך ישמור את מצב המשבצת המתאימה בלוח הערך true יתאר משבצת פנויה, ואילו הערך false יתאר מוקש בנוסף נזדקק למשתנה שיציין את מיקום השחקן על הלוח אם כך אלה יהיו המשתנים שנשתמש בהם: board מערך של 30 איברים מטיפוס בוליאני pawn מטיפוס שלם, לשמירת מיקום השחקן על הלוח למשל עבור הדוגמה שלעיל המערך board ייראה כך: [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [27] [28] [29] true true true false true false true true true false true false true true והמשתנה pawn יכיל את הערך 1 (כיוון שהשחקן נמצא על המשבצת השנייה) ההתייחסות לאיברי המערך היא בעזרת מציין, לדוגמה הערך בתא board[pawn] מבטא את מצב המשבצת שכלי השחקן מוצב עליה שימו : אמנם לוח המשחק ממוספר מ- 1 עד 30, אבל המערך המתאר אותו ממוספר מ- 0 עד 29 לכן ערכי המשתנה pawn יהיו בתחום 0 עד 29 האלגוריתם? כיצד נשתמש במערך board כדי לחשב את ההטלות שעבורן יוכל השחקן להתקדם? כדי לחשב את ההטלות שעבורן יוכל השחקן להתקדם יש לבדוק את מצבן של שש המשבצות העוקבות למשבצת שהשחקן מוצב עליה כיוון שמשבצת זו מתוארת באמצעות האיבר board[pawn] במערך, שש המשבצות העוקבות מיוצגות על ידי ששת האיברים הבאים לפי הסדר: board[pawn+6],,board[pawn+2],board[pawn+1] עבור כל איבר מששת האיברים האלה יש לבדוק אם הוא מייצג משבצת פנויה (כלומר אם ערכו הוא (true אם כן, יש להציג כפלט את הטלת הקובייה אשר מביאה אליו את השחקן למשל, אם ערכו של board[pawn+3] מבטא משבצת פנויה, יוצג 3 כפלט, כיוון שהטלת 3 בקובייה מביאה את השחקן למשבצת פנויה :òöá 1 ìë øåáò úåçô êøòîä ìãåâ ãò 0-î íìù i çåìä ìù i-ä úöáùîä áöî úà èåì 11 ï çùä íå éî úà èåì :òöá 6 ãò 1-î íìù i ìë øåáò ä éø àéä ï çùä íå éîî i çøîá úöáùîä íà 31 i ìù åëøò úà âöä

14 התוכנית המלאה /* קלט: תיאור לוח משחק בן 30 משבצות ומיקום משבצת שעליה מוצב שחקן (בין 1 ל- 24 ) /* פלט: הטלות קובייה המביאות את השחקן למשבצת פנויה import javautilscanner; public class MineBoardGame public static void main (String[] args) Scanner in = new Scanner(Systemin); הגדרת קבוע // final int BOARD_SIZE = 30; הגדרת משתנים // boolean[] board = new boolean[board_size]; char cellstatus; int pawn; קלט הלוח // Systemoutprintln("Enter the board details: Type F for a " + "cell with a mine, and T for a free cell: "); for (int i = 0; i < boardlength; i++) Systemoutprint("Enter status of cell number " + (i+1)); cellstatus = innextline()charat(0); board[i] = (cellstatus == 'T'); } קלט מיקום השחקן והתאמתו לאופן שמירת הלוח // Systemoutprint("Enter the pawn position: "); pawn = innextint(); pawn = pawn - 1; פלט // Systemoutprintln("Throws that lead to empty positions: "); for (int i = 1; i <= 6; i++) if (board[pawn + i]) Systemoutprintln(i); }// main } //class MineBoardGame שימו : בלולאה הראשונה השתמשנו במציין i כדי לעדכן את מצב המשבצת התורנית בלוח כדי להודיע למשתמש את מספר המשבצת שאת מצבה עליו להקליד השתמשנו בביטוי + 1 i הביטוי מתאים את מצייני המערך (הנעים בין 0 ל- 29 ) לאופן הספירה של הלוח (מ- 1 עד 30) וכך בסיבוב הראשון של הלולאה, כאשר ערכו של i הוא 0, מוצגת ההודעה: Enter status of cell number 1: בלולאה השנייה השתמשנו בביטוי pawn + i כמציין הביטוי pawn + i מבטא מיקום במערך שמרחקו מהמיקום pawn הוא i לאחר קליטת מיקום השחקן, מדוע מושם במשתנה pawn הערך הנקלט פחות 1? המשתמש בתוכנית יקליד את מיקום השחקן על הלוח כמספר שלם בין 1 ל- 30 לעומת זאת, ערכי המשתנה pawn צריכים להתאים לאופן מספור המערך מ- 0 עד 29? סוף פתרון בעיה

15 ב ג ד שאלה 1015 בנו טבלת מעקב אחר מהלך ביצוע התוכנית MineBoardGame לפתרון בעיה 3 עבור הקלט: T T F F T F T F T T 2 כלומר יש מוקש במשבצת השלישית והרביעית, ומהמשבצת השישית ואילך יש מוקש בכל משבצת זוגית השחקן נמצא במשבצת השנייה מהו הפלט המתקבל? שאלה 1016 הרחיבו את האלגוריתם לפתרון בעיה 3 כך שיציג כפלט לא רק את ההטלות שמאפשרות לשחקן להתקדם, אלא גם את מספרי המשבצות שהטלות אלו מובילות אליהן למשל עבור הקלט שבשאלה הקודמת יכלול הפלט החדש גם את הרשימה: 5 7 שאלה 1017 נניח שכתבנו את משפטי ההצהרה הבאים: int[] arr = new int[100]; int position; int counter = 0; באיברי המערך arr הושמו ערכים ובמשתנה position נקלט ערך חיובי שלם בתחום 1 עד 79 א תארו את מטרת קטע התוכנית הבא: if (arr[position] == arr[position - 1]) Systemoutprintln("previous one is equal"); if (arr[position] == arr[position + 1]) Systemoutprintln("next one is equal"); תארו את מטרת קטע התוכנית הבא: for (int i = 0; i < 10; i++) if (arr[position] == arr[position + i]) counter = counter + 1; Systemoutprintln(counter); כתבו לולאה שמטרתה להציג את מצייניהם של איברי המערך, מבין 20 האיברים העוקבים ל-[ arr[position, אשר ערכם גדול מערכו של arr[position] כתבו לולאה שמטרתה להציג את מצייניהם של איברי המערך, מבין 20 האיברים העוקבים ל-[ arr[position, אשר ערכם גדול בדיוק ב- 1 מערכו של arr[position] שאלה 1018 פתחו וישמו אלגוריתם אשר הקלט שלו הוא רצף של 20 תווים, והפלט שלו הוא מספר הזוגות של תווים עוקבים ששווים לזוג התווים האחרון למשל, עבור הקלט abcabacadcababddaaab הפלט הוא 4 כיוון שהזוג האחרון הוא,ab ויש עוד ארבעה זוגות השווים ל- ab שימו : עבור קלט של 20 תווים זהים הפלט צריך להיות 18 (כיוון שכל הזוגות, מהראשון ועד הזוג לפני האחרון, שווים לזוג האחרון) שאלה 1019 במשחק נתון לוח הכולל שורה של 25 משבצות אשר בכל אחת מהן רשום מספר שלם בין 0 ל- 5 על הלוח מוצב שחקן בין המשבצת העשירית והחמש-עשרה

16 השחקן מטיל קובייה כדי לנסות ולהתקדם על הלוח אם המספר המתקבל בהטלת הקובייה מוביל למשבצת אשר המספר הרשום בה קטן או שווה למספר המתקבל בקובייה, השחקן מקדם את הכלי למשבצת זו אחרת השחקן נסוג אחורה מספר משבצות השווה למספר המתקבל בקובייה פתחו אלגוריתם אשר הקלט שלו הוא תיאור הלוח (25 מספרים שערכיהם נעים בין 0 ל- 5 ), ואחריו מיקום השחקן על הלוח וערכה של הטלת הקובייה הפלט שלו הוא מיקומו החדש של השחקן על הלוח ישמו את האלגוריתם בשפת Java שימו : יש להתאים בין מיקום השחקן כפי שנקלוט (מספר בין 1 ל- 25 ) לבין מציין המערך (מספר בין 0 ל- 24 ) שאלה 1020 מה יהיו ערכי איברי המערך בסיום קטע התוכנית הבא? int[] arr = new int[10]; for (int i = 0; i < arrlength / 2; i++) arr[i * 2] = i; המכיל מספרים שלמים תארו מה יהיו ערכי איברי המערך for (int i = 0; i < arrlength; i++) arr[i] = arr[arrlength - i]; 10 שאלה 1021 המערך arr הוא מערך באורך בסיום קטע התוכנית הבא ב שאלה 1022 א המערך arr הוא מערך באורך 10 המכיל מספרים שלמים תארו מה יהיו ערכי איברי המערך בסיום קטע התוכנית הבא for (int i = 0; i < arrlength - 1; i++) arr[i + 1] = arr[i]; ב תקנו את קטע התוכנית וכתבו אותו מחדש כך שיבצע הזזה של ערכי התאים במערך בצורה מעגלית, כלומר, התא השני יכיל את ערכו המקורי של התא הראשון, התא השלישי יכיל את ערכו המקורי של התא השני וכן הלאה, והתא הראשון יכיל את ערכו המקורי של התא האחרון שאלה 1023 א חברי קבוצת "סיורי הגליל" הולכים תמיד בטור, זה אחר זה לאחר עשרים דקות הליכה, הראשון בטור נעצר וממתין עד שהטור כולו עובר אותו, ואז מצטרף לטור שוב כאחרון פתחו אלגוריתם המקבל כקלט את מספר חברי הקבוצה, ולאחר מכן את רשימת השמות של חברי הקבוצה, לפי הסדר שבו הם מתחילים את הטיול פלט האלגוריתם יהיה סדר חברי הקבוצה לאחר שעה ורבע של הליכה ישמו את האלגוריתם בשפת התכנות Java חברי קבוצת "סיורי הגליל למתחילים" הולכים תמיד בטור; המדריך צועד בראש, ובסוף נמצאים החובש, המלווה והמאסף בקדמת הטור צועדות הבנות ואחריהן צועדים הבנים רק הבנים מחליפים את מקומותיהם כל עשרים דקות כפי שתואר עבור קבוצת "סיורי הגליל" פתחו אלגוריתם המקבל כקלט את מספר הבנים ואת מספר הבנות בקבוצה, ואת הרשימה של שמות חברי הקבוצה לפי הסדר שבו הם מתחילים את הטיול פלט האלגוריתם יהיה סדר חברי הקבוצה לאחר שעה ורבע של הליכה ישמו את האלגוריתם בשפת התכנות Java

17 שאלה 1024 פתחו אלגוריתם המקבל כקלט סדרת מספרים בסדר עולה האלגוריתם מסדר ושומר את הסדרה הנתונה בסדר יורד ישמו את האלגוריתם בשפת התכנות Java 102 חריגה מגבולות מערך? בהגדרת בעיה 3 נכללה הנחה כי השחקן מוצב על משבצת שמספרה בין 1 ל- 24 מדוע הנחה זו חשובה? נניח כי השחקן עומד על משבצת שערכה גבוה מהמספר 24, למשל 25 הטלת הקובייה נותנת מספר כלשהו בין 1 ל- 6 אם הטלת הקובייה תיתן את המספר 6, השחקן ינסה לנוע 6 צעדים קדימה החל מהמשבצת ה- 25 כך יגיע השחקן למשבצת מספר 31 משבצת זו אינה קיימת כמובן ואינה חוקית בתנאי המשחק! ניסיון להתייחס במהלך הרצת תוכנית בשפת Java לתא שאיננו קיים במערך (למשל (board[30] יגרום להפסקת פעולתה של התוכנית ולהצגת הודעת שגיאה על חריגה מגבולות המערך חריגה מגבולות המערך היא שגיאת ריצה, המתגלה בזמן ריצת התוכנית ולא בזמן ההידור שאלה 1025 נוסיף לפתרון בעיה 3 משתנה בשם limit מטיפוס שלם, אשר ישמש כערך סופי למשתנה הבקרה i של הלולאה השנייה (לולאת הצגת הפלט) נשתמש ב- limit כדי להרחיב את משפטי התוכנית,MineBoardGame כך שהתוכנית תאפשר לקלוט ערך בין 1 ל- 29 למיקום השחקן (במקום 24 כמו בבעיה המקורית) יחד עם זאת לא תהיה חריגה מגבולות המערך בלולאה השנייה לפני הלולאה השנייה נוסיף הוראה לביצוע-בתנאי: if ( ) else וכותרת הלולאה השנייה תהיה: for (int i = 1; i <= limit; i++) השלימו את ההוראה לביצוע-בתנאי, כך שהתוכנית תבצע את הדרוש int[] arr = new int[8]; שאלה 1026 נתון המערך arr שהצהרתו היא: וערכי איבריו הם: arr[0] 10 arr[1] 20 arr[2] 40 arr[3] 30 arr[4] 4 arr[5] 5 arr[6] 7 arr[7] 6 for (int i = 0; i < arrlength - 1; i++) if ((i == arr[i]) (i == arr[i + 1])) Systemoutprintln(i); א מה יהיה פלט הלולאה הבאה?

18 מה יהיו ערכי המערך אחרי ביצוע הלולאה הבאה? for (int i = 0; i < arrlength; i++) if (arr[i] == (10 * i)) arr[i] = arr[i] + 1; else arr[i] = arr[i] - 1; } עבור אילו מארבעת הלולאות הבאות תהיה חריגה מגבולות המערך? תקנו לפי הצורך 1 for (int i = 0; i < arrlength; i++) arr[i] = arr[i + 1]; 2 for (int i = 0; i < arrlength - 1; i++) arr[i] = arr[i - 1]; 3 for (int i = 0; i < arrlength - 1; i++) arr[i] = arr[i] * 2; 4 for (int i = 0; i < arrlength - 1; i++) arr[i] = arr[i * 2]; שאלה 1027 השאלה מתייחסת למערך arr בן 8 האיברים שהוגדר בשאלה הקודמת כתבו לולאה אשר תשווה את ערכיהם של כל זוג איברים שכנים במערך arr[0]) ל-[ arr[1, arr[1] ל-[ arr[2, arr[6], ל-[ arr[7 ), ותחשב את מספר זוגות האיברים השכנים שערכיהם שווים זה לזה שימו : לא לחרוג מגבולות המערך ב ג שאלה 1028 על תמר הוטל לכתוב תוכנית המגדירה מערך בן 50 תאים, ומציבה בהם את הערכים: תמר כתבה: double[] arr = new double[50]; for (int i = 0; i < arrlength * 2; i++) arr[i] = i / 2; האם קטע התוכנית נכון? אם איננו נכון תקנו את השגיאות כך שתושג המטרה המבוקשת for (int i = 0; i < n - 2; i++) if (a[i] + 2 == a[i + 2]) Systemoutprintln(i + " " + a[i]); שאלה 1029 (מבגרות 2002) לפניכם קטע תוכנית: a הוא המערך הבא בגודל 10: a: א עקבו בעזרת טבלת מעקב אחר קטע התוכנית עבור 10=n ועבור המערך a הנתון, ורשמו מה יהיה הפלט ב הסבירו מדוע קבע כותב קטע התוכנית שהתנאי להמשך ביצוע הלולאה יהיה 2-n i < ולא i<n

19 103 קשרים בין מערכים בדוגמאות שראינו עד כה השתמשנו במערך יחיד לעתים פתרון בעיה מצריך יותר ממערך אחד בסעיף זה נראה פתרונות אלגוריתמיים המשתמשים ביותר ממערך אחד בחלקו הראשון של הסעיף נציג עיבוד של כמה מערכים במקביל בקצב התקדמות זהה, ובחלקו השני נעסוק גם בעיבוד של כמה מערכים שאינו נעשה באותו קצב התקדמות עיבוד מערכים במקביל ובקצב התקדמות זהה השאלה הבאה עוסקת בניתוח קטע תוכנית המעבד במקביל שני מערכים, שאחריה מצריך שימוש בשלושה מערכים ופתרון השאלה שאלה 1030 m1 ו- m2 הם שני מערכים שהוצהרו באופן הבא: final int SIZE = 10; int m1[] = new int[size]; int m2[] = new int[size]; נתונים שני קטעי התוכניות הבאים אשר אמורים להציג כפלט אם שני המערכים מכילים בדיוק את אותם איברים באותו סדר boolean compare = false; for (int i = 0; i < SIZE; i++) compare = (m1[i] == m2[i]); if (compare) Systemoutprintln("The arrays are equal"); else Systemoutprintln("The arrays are not equal"); II I boolean compare = false; for (int i = 0; i < SIZE; i++) if (m1[i] == m2[i]) compare = true; if (compare) Systemoutprintln("The arrays are equal"); else Systemoutprintln("The arrays are not equal"); שני קטעי התוכניות שגויים ענו על הסעיפים הבאים ביחס לכל אחד מהקטעים: א הביאו דוגמה לערכים של איברים בשני המערכים שקטע התוכנית משיג את מטרתו עבורם ב הביאו דוגמה לערכים של איברים בשני המערכים שקטע התוכנית אינו משיג את מטרתו עבורם, והסבירו מדוע זה קורה ג תקנו את קטע התוכנית כך שישיג את מטרתו שאלה 1031 כיתה י' 5 ניגשה למבחן לאחר המבחן הוחלט כי הכיתה כולה תיגש למבחן נוסף, והציון הגבוה מבין שני ציוני המבחנים לכל תלמיד יהיההציון הקובע פתחו אלגוריתם הקולט את מספר התלמידים בכיתה, ולאחר מכן קולט את ציוני המבחן הראשון למערך בשם grade1 ואת ציוני המבחן השני למערך בשם grade2 האלגוריתם ימלא מערך בשם finalgrade כך שיכיל את הציון הקובע לכל אחד מתלמידי הכיתה, ויציג כפלט עבור כל אחד מהתלמידים את ציון המבחן הראשון, את ציון המבחן השני ואת הציון הקובע בליווי הודעות מתאימות ישמו את האלגוריתם בשפת Java

20 עיבוד מערכים במקביל בקצב התקדמות לא זהה בעיה 4 מטרת הבעיה ופתרונה: הצגת עיבוד של כמה מערכים במקביל בקצב התקדמות לא זהה פתחו אלגוריתם המקבל כקלט מספר חיובי שלם,num ולאחר מכן קורא מהקלט num מספרים שלמים לתוך מערך numbers האלגוריתם מעתיק מהמערך numbers את המספרים החיוביים למערך positive ואת המספרים השליליים למערך,negative ושומר על סדר המספרים ישמו את האלגוריתם בשפת Java ניתוח הבעיה בעזרת דוגמאות נניח כי הקלט הוא המערך numbers ישמור בתוכו 5 מספרים שלמים בעקבות ההעתקה הדרושה יכיל המערך positive שלושה איברים: 3 1, ו- 4 המערך negative יכיל שני איברים: 1- ו- 2 - אנו רואים כי לא רק שלכל מערך מועתק מספר שונה של איברים, אלא שקצב ההתקדמות על המערכים הללו שונה: ייתכן כי נסרוק כמה איברים ברצף במערך,numbers נשים אותם באחד המערכים, אך במקביל לא נתקדם כלל בהשמה במערך האחר למשל בדוגמת הקלט שלעיל, בזמן שבמערך numbers נסרק האיבר השלישי והרביעי בזה אחר זה, אין כלל התקדמות במילוי המערך negative פירוק הבעיה לתת-משימות קליטת מספר הערכים לעיבוד קליטת רשימת הערכים ושמירתה במערך numbers ביצוע במקביל של סריקת המערך numbers ומילוי המערכים positive ו- negative בחירת משתנים כדי לסרוק את המערכים בקצב התקדמות לא זהה, עלינו לשמור שלושה מציינים שונים, אחד עבור כל מערך: המציין של המערך numbers יסרוק את איברי המערך בזה אחר זה המציין של המערך positive והמציין של המערך negative יצביעו בכל רגע על המקום הפנוי הבא במערך המתאים להם, כדי שהעתקת האיבר הבא תתבצע למקום הנכון המציין של המערך numbers יתקדם ב- 1 בכל פעם שנסיים עיבוד של איבר תורן במערך ונתקדם לעבר האיבר הבא כל אחד מהמציינים האחרים, של המערך positive ושל המערך,negative יתקדם ב- 1 רק אחרי ביצוע העתקה למערך שאליו הוא מתייחס נשתמש במשתנים הבאים: size מספר הערכים לעיבוד size מערך מטיפוס שלם, בגודל numbers size מערך מטיפוס שלם, בגודל positive size מערך מטיפוס שלם, בגודל negative

21 numbers מטיפוס שלם, יציין את מיקום האיבר התורן במערך indexnum positive מטיפוס שלם, יציין את המקום הפנוי הבא במערך indexpos negative מטיפוס שלם, יציין את המקום הפנוי הבא במערך indexneg האלגוריתם size-á íìù éáåéç êøò èåì :òöá size-1 ãò 0-î íìù i ìë øåáò numbers[i]-á ïåúð èåì 21 0-á indexpos úà ìçúà 0-á indexneg úà ìçúà :òöá size-1 ãò 0-î íìù indexnum ìë øåáò numbers[indexnum] > 0 íà 51 positive[indexpos]-ì numbers[indexnum] ìù åëøò úà úòä á indexpos ìù åëøò úà ìãâä 512 úøçà 52 negative[indexneg]-ì numbers[indexnum] ìù åëøò úà úòä á indexneg ìù åëøò úà ìãâä שאלה 1032 ישמו את האלגוריתם לפתרון בעיה 4 בשפת Java 4 סוף פתרון בעיה שאלה 1033 פתחו אלגוריתם אשר מקבל כקלט מספר חיובי שלם, ולאחר מכן קולט רשימת מספרים שאורכה כערך הנתון הראשון האלגוריתם ישמור את המספרים הנקלטים בשני מערכים שונים, מערך אחד עבור מספרים זוגיים, ומערך אחר עבור מספרים אי-זוגיים האלגוריתם יציג כפלט את כל הערכים שברשימה: ראשית את כל המספרים הזוגיים, לפי סדר קליטתם ואחר-כך את כל המספרים האי-זוגיים לפי סדר קליטתם ישמו את האלגוריתם בשפת Java שאלה 1034 נניח ש- arr1 ו- arr2 הם שני מערכים מטיפוס שלם ואורכם אינו בהכרח שווה כתבו קטע תוכנית אשר מעתיק למערך שלישי,arr3 רק את האיברים אשר נמצאים גם ב- arr1 וגם ב- arr2 למשל, אם ב- arr1 וב- arr2 נמצאים הערכים הבאים: arr arr אז ב- arr3 יהיו הערכים הבאים: arr הדרכה: יש להשתמש בקינון של לולאות

22 104 מערך מונים בפרק 7 למדנו על משתנה מסוג מונה למדנו כי מונה הוא משתנה אשר תפקידו למנות מספר של אירועים שמתרחשים (כמו למשל הופעות של נתוניםאו מספר חישובים שביצענו) כיוון שהשימוש במונה הוא לצורך ספירה, מונה הוא משתנה מטיפוס שלם לעתים יש למנות במקביל אירועים שונים לשם כך ניתן להשתמש במערך של מונים, כפי שמדגימה הבעיה הבאה העבודה עם מערך מונים היא תבנית שימושית לפתרון בעיות אלגוריתמיות בעיה 5 מטרת הבעיה ופתרונה: הצגת מערך מונים ושימוש בו בתוכנית "כוכב נולד" יש N מועמדים ולכל מועמד מספר סידורי בין 1 ל- N הצופים בבית נתבקשו לבחור את אחד המועמדים ולהצביע עבורו בכל תוכנית המועמד שמקבל את מספר הקולות הקטן ביותר עוזב את התוכנית פתחו אלגוריתם אשר מקבל כקלט את מספר המועמדים (מספר חיובי שלם), ואחר כך קולט רשימה של הצבעות של הצופים, המסתיימת במספר - 1 האלגוריתם מודיע מי המועמד אשר קיבל את מספר הקולות הקטן ביותר ישמו את האלגוריתם בשפת התכנות Java פירוק הבעיה לתת-משימות קליטת מספר מועמדים קליטת הצבעות למועמדים תוך מניה של ההצבעות עבור כל מועמד מציאת המונה בעל הערך המינימלי והצגה של המועמד שאליו הוא מתאים בחירת משתנים כדי לבצע את תת-משימה 2 עלינו לתפעל במקביל כמה מונים, מונה לכל מועמד כלומר מספר המונים שווה למספר המועמדים כמובן שאין אנו יכולים להצהיר על מונה נפרד לכל מועמד: מספר המועמדים אינו ידוע מראש, ואפילו אם היה ידוע, ייתכן כי הוא גדול למדי בכל מקרה, הצהרה על מונה נפרד לכל מועמד הופכת את התוכנית למסורבלת, לפחות קריאה ולקשה יותר לשינוי (למשל אם מספר המועמדים ישתנה) לכן ניצור מערך שאורכו כמספר המועמדים, וכל תא בו י י צג מונה נזדקק למשתנים הבאים: numofsingers מטיפוס שלם, שומר את מספר המתמודדים בתחרות votes מערך מטיפוס שלם, מערך מונים באורך numofsingers למניית ההצבעות עבור כל מועמד ומועמד vote מטיפוס שלם, שומר הצבעה תורנית מהקלט min מטיפוס שלם, לשמירת ההצבעה המצטברת הנמוכה ביותר minsinger מטיפוס שלם, שומר את מספר המתמודד שקיבל את מספר ההצבעות הנמוך ביותר

23 האלגוריתם לצורך ביצוע תת-משימה 2 יש להשתמש בלולאה, אשר בכל סיבוב בו תיקלט הצבעה נוספת מהקלט, ובהתאם לערכה יגדל ערכו של המונה המתאים מאחר שמספר ההצבעות אינו ידוע מראש, ומאחר שסוף רשימת ההצבעות מצוין בזקיף, נשתמש בלולאת while שהתנאי בה מתייחס לזקיף לצורך ביצוע תת-משימה 3 נחפש את האיבר הקטן ביותר במערך המונים שימו : יש להציג כפלט את מספרו הסידורי של המתמודד שקיבל את מספר הקולות הקטן ביותר, ולא את מספר הקולות שקיבל לכן במקרה זה נשתמש בתבנית של מציאת מקום המינימום numofsingers-á íéããåîúîä øôñî úà èåì 1 vote-á ãîòåî øôñî èåì 2 :òöá vote -1 ãåò ìë 3 vote åøôñîù ããåîúîä ìù (êøòîá) äðåîä úà 1-á äìòä 31 vote-á ãîòåî øôñî èåì 32 ïåùàøä ããåîúîä ìù äðåîä êøòá min úà ìçúà4 1-á minsinger úà ìçúà5 :òöá numofsingers ãò 2-î íìù i ìë øåáò 6 min-î ïè i øôñî ããåîúî ìù äðåîä êøò íà 61 i åøôñîù ããåîúîä ìù äðåîä êøò úà min-á íùä 611 minsinger-á i úà íùä 612 minsinger êøò úà âöä 7 יישום האלגוריתם חשוב לשים לב כי המספרים הסידוריים של המועמדים מתחילים ב- 1, בעוד שמספור איברי המערך מתחיל מ- 0 לכן למשל היישום של הוראה 31 באלגוריתם הוא votes[vote 1]++; if (votes[i 1] < min) והיישום של הוראה 61 הוא התוכנית המלאה קלט : מספר המועמדים בתוכנית "כוכב נולד" והצבות הצופים למועמדים */ /* פלט: המספר הסידורי של המתמודד המפסיד import javautilscanner; public class IsraeliIdol public static void main (String[] args) Scanner in = new Scanner(Systemin); הגדרת משתנים // int numofsingers; int[] votes; int vote; int min; int minsinger;

24 קליטת מספר מועמדים והקצאת גודל מערך מתאים // Systemoutprint("Enter number of contestants: "); numofsingers = innextint(); votes = new int[numofsingers]; אתחול מערך המונים // for(int i = 0; i < numofsingers; i++) votes[i] = 0; קליטת בחירת הצופים בלולאת זקיף // Systemoutprint("Enter a vote, end the list with -1 "); vote = innextint(); while (vote!= -1) הוספת קול נוסף למונה המתאים // votes[vote - 1]++; Systemoutprint("Enter a vote, end the list with -1 "); vote = innextint(); } אתחול משתני מינימום ומקום המינימום // min = votes[0]; minsinger = 1; חיפוש ערך מינימלי ושמירת ערכו וערך המציין שלו // for(int i = 2; i <= numofsingers; i++) if (votes[i - 1] < min) min = votes[i - 1]; minsinger = i; } // if } // for פלט // Systemoutprintln("contestant number " + minsinger + " is going home"); } //main } //class IsraeliIdol שימו : כשם שיש לאתחל משתנה מסוג מונה לאפס, כך גם יש לאתחל כל איבר ואיבר במערך מונים ב- 0 אנו מבצעים אתחול כזה במפורש, למרות שיכולנו להסתמך על כך שבשפת Java איבריו של מערך מטיפוס מספרי מאותחלים אוטומטית ב- 0 אתחול מפורש תורם לבהירות התוכנית ועוד שימו : את תבנית מציאת מקום המינימום ניתן גם ליישם בצורה מעט שונה, הנוחה לעבודה עם מערכים למעשה ביישום זה נשמר רק מקום האיבר המינימלי ולא ערכו, ואנו מסתמכים על כך שבמערך קל לברר את ערכו של איבר כאשר ידוע המציין שלו: חיפוש ערך מינימלי ושמירת ערך המציין שלו // for(int i = 2; i <= numofsingers; i++) if (votes[i - 1] < votes[minsinger]) minsinger = i; Systemoutprintln("contestant number " + minsinger + " is going home"); סוף פתרון בעיה

25 להעמקה בתבנית מערך מונים פנו לסעיף התבניות המופיע בסוף הפרק שאלה 1035 עקבו אחר התוכנית IsraeliIdol בעזרת טבלת מעקב, עבור הקלט (משמאל לימין) שאלה 1036 בכיתה נערכה הצבעה לנציג הכיתה למועצת תלמידים כל תלמיד הקליד במחשב את בחירתו על פי המפתח הבא: עבור רותי יוקלד הערך 1, עבור אלי הערך 2, עבור אביב הערך 3, ועבור אופיר הערך 4 פתחו אלגוריתם המקבל כקלט את מספר התלמידים בכיתה ואת רשימת ההצבעות (הצבעה אחת מכל תלמיד בכיתה) ומציג כפלט את שם המועמד המנצח ישמו את האלגוריתם בשפת Java שאלה 1037 פתחו אלגוריתם הקולט מספר חיובי שלם, ואחר כך מדמה סדרת הטלות קובייה, שאורכה כערך המספר שנקלט פלט האלגוריתם הוא מספר הפעמים שהוגרלה כל אחת משש התוצאות האפשריות להטלת קובייה ישמו את האלגוריתם בשפת התכנות Java שאלה 1038 ששת חברי קבוצה בצופים מצאו דרך חדשה להגרלה הם מחלקים ביניהם את המספרים מ- 1 עד 6, ומטילים קובייה עד אשר מספר כלשהו מוגרל פעמיים החבר בעל המספר שהוגרל פעמיים הוא הזוכה פתחו אלגוריתם אשר מדמה את תהליך זריקת הקובייה ומדפיס את המספר הזוכה ישמו את האלגוריתם בשפת התכנות Java שאלה 1039 בפתרון הבעיה הקודמת השתמשנו במערך מונים, אך בכל מהלך הביצוע ערכיו לא עברו אף פעם את הערך 2 שינוי אחד הערכים במערך ל- 2 הביא לסיום האלגוריתם שנו את הפתרון כך שבמקום מערך מטיפוס שלם, ישתמש במערך מטיפוס בוליאני ישמו את הפתרון החדש בשפת Java שאלה 1040 במשחק "תפוס את הצבע" כל שחקן בוחר צבע שונה הקלט הוא מספר השחקנים והצבע שכל שחקן בחר לאחר מכן עבור כל הקשה על מקש enter מוגרל צבע כלשהו (מתוך הצבעים שנבחרו) המשחק מסתיים כאשר מקישים על האות Q בסוף המשחק בודקים מהו הצבע שהוגרל הכי הרבה פעמים ומציגים את הצבע הזוכה כפלט כתבו תוכנית שתדמה את "תפוס את הצבע" הדרכה: מאתחלים מערך צבעים לפי הקלט שמתקבל מהשחקנים, לדוגמה עבור הקלט: 4, אדום, ירוק, צהוב, סגול, יתקבל המערך הבא: סגול צהוב ירוק אדום את הצבעים יש להגריל מתוך הצבעים שנקלטו בנוסף, יש להגדיר מערך מונים לספירת ההגרלות לכל צבע

26 105 מערך צוברים באותו אופן שמימשנו מערך של מונים, ניתן לממש מערך של צוברים במערך צוברים כל איבר הוא צובר בפני עצמו, אך יש קשר בין משימות הצבירה שהצוברים השונים במערך אחראים להן לצורך פתרון השאלה הבאה יש להשתמש במערך צוברים, שהעבודה עמו מהווה אף היא תבנית שימושית שאלה 1041 במשחק קלפים משתתפים ארבעה שחקנים ולהם מספרים סידוריים מ- 1 עד 4 בכל סבב מוכרזים השחקנים שזכו במקום הראשון, במקום השני ובמקום השלישי השחקן הנותר נחשב כמפסיד המנצח במקום הראשון מקבל 7 נקודות, השחקן שבמקום השני מקבל 3 נקודות, השחקן שבמקום השלישי אינו מקבל נקודות והמפסיד מאבד 4 נקודות המנצח במשחק כולו הוא זה שקיבל את מרב הנקודות בסיום כל הסבבים פתחו אלגוריתם אשר מקבל כקלט את מספר הסבבים, ולאחר מכן מקבל עבור כל סבב את מספרי השחקנים שהגיעו למקום הראשון, השני והשלישי האלגוריתם מציג כפלט את מספרו של השחקן המנצח במשחק ישמו את האלגוריתם בשפת Java שימו : מאחר שניתן גם לאבד נקודות, ייתכן ששחקן יגיע למספר נקודות שלילי שאלה 1042 בספריית הווידיאו יש לכל סרט קוד בן 4 ספרות הספרה השמאלית ביותר מסמנת את קוד המחלקה (בין 1 ל- 6 ), שתי הספרות האמצעיות מסמנות את קוד הסרט (בין 1 ל- 99 ) והספרה הימנית ביותר מסמנת את מספר העותקים בספרייה (בין 1 ל- 9 ) פתחו אלגוריתם המקבל כקלט רשימה של הקודים של כל הסרטים בספרייה המסתיימת במספר 0 פלט האלגוריתם הוא: א קוד המחלקה שיש בה את מספר הסרטים (השונים) הגדול ביותר ב קוד המחלקה שיש בה את מספר עותקי הסרטים הגדול ביותר ישמו את האלגוריתם בשפת Java שאלה 1042 עוסקת במציאת איבר שכיח במערך התבניות המופיע בסוף הפרק להעמקה בתבנית חישוב שכיח לסעיף פנו להעמקה בתבנית מערך צוברים פנו לסעיף התבניות המופיע בסוף הפרק 106 יעילות מקום בכל הבעיות שפתרנו בפרק זה נעזרנו במערך, ועבור כל בעיה ראינו את נחיצות השימוש במערך במהלך הפתרון בסעיף הבא נתמקד באבחנה בין בעיות אשר בפתרונן נחוץ מערך ובין בעיות אשר ניתן לפתור גם ללא מערך, ונבין מדוע לא כדאי להשתמש במערך אם אין בו צורך בעיה 6 מטרת הבעיה ופתרונה: הצגת המדד של יעילות מקום, והשוואה של אלגוריתמים ביחס ליעילות מקום מבט נוסף אל יעילות מבחינת זמן-ביצוע

27 ערוצי הכבלים עורכים מדי פעם סקרים כדי לברר את אחוזי הצפייה בתוכניותיהם השונות פרסום תוצאות סקר כזה כולל רשימת תוכניות יחד עם אחוז צפייה בכל תוכנית א פתחו אלגוריתם אשר הקלט שלו הוא מספר של תוכניות (שלם וחיובי), ולאחר מכן רשימה של אחוזי צפייה בתוכניות ואורכה כערך הנתון הראשון הפלט הוא מספר התוכניות שאחוז הצפייה בהן גבוה מממוצע אחוזי הצפייה ב פתחו אלגוריתם אשר הקלט שלו הוא מספר של תוכניות (שלם וחיובי), ולאחר מכן רשימה של אחוזי צפייה בתוכניות ואורכה כערך הנתון הראשון הפלט הוא מספר התוכניות שאחוז הצפייה בהן גבוה מ- 20% ג האם תשובתכם לסעיף א תשתנה אם ידוע כי רשימת אחוזי הצפייה נתונה בסדר יורד (כלומר תחילה נתון אחוז הצפייה בתוכנית האהודה ביותר, אחר-כך אחוז הצפייה התוכנית האהודה הבאה וכך הלאה, עד אחוז הצפייה בתוכנית שנצפית הכי פחות)? נתחיל בסעיף א הבעיה המוגדרת בסעיף א זהה לחלוטין לבעיה 2 יש לקלוט אורך של רשימת נתונים לא ריקה, לקלוט את הרשימה עצמה, לחשב את ממוצע הערכים, ולמנות את הערכים הגדולים מהממוצע מאחר שכבר פתרנו בעיה זהה לה, לא נחזור כעת על הפתרון בפירוט, רק נזכיר שהפתרון משתמש במערך לשמירת ערכי הקלט (במקרה זה, רשימת אחוזי הצפייה) נעבור כעת לסעיף ב ניתוח הבעיה בעזרת דוגמאות נניח כי הקלט הוא במקרה זה הפלט הוא 2, כי אחוז הצפייה בשתי תוכניות (הראשונה והרביעית) גבוה מ- 20% אין אנו נדרשים לחשב ממוצע של אחוזי הצפייה פירוק הבעיה לתת-משימות ניתן להציג פירוק הדומה לפירוק המתאים לסעיף א: 1 קליטת מספר התוכניות 2 קליטת אחוזי הצפייה ושמירתם 3 השוואת כל אחוז צפייה ל- 20 ומנייתו אם הוא גדול מ- 20 פירוק זה אכן מורה על שימוש במערך קודם כל נשמרים הנתונים, ואחר כך הם מעובדים (במקרה זה, מושווים ל- 20 ונמנים בהתאם לתוצאת ההשוואה) האם ניתן להציג פירוק פשוט יותר, שאינו מחייב שימוש במערך? כן! ניתן לעבד כל נתון נקלט מיד עם קליטתו, להשוותו ל- 20, ולהחליט אם למנות אותו או לא, ובעצם אין צורך בשמירת ערכי הקלט לאחר מכן לכן נקבל את הפירוק הבא לתת-משימות: קליטת מספר התוכניות קליטת אחוזי הצפיה, ועבור כל אחוז צפייה נקלט, השוואתו ל- 20 ועדכון המונה בהתאם 1 2 בחירת משתנים מאחר שכאמור אין צורך במערך נשתמש במשתנים הבאים: numofprograms מטיפוס שלם, ישמור את מספר התוכניות rate מטיפוס ממשי, ישמור את אחוז הצפייה התורן בקלט

28 above20counter מטיפוס שלם, מונה לשמירת מספר אחוזי הצפייה הגבוהים מ- 20 האלגוריתם numofprograms-á úåéðëåúä øôñî úà èåì 1 0-ì above20counter ìù åëøò úà ìçúà 2 :òöá numofprograms ãò 0-î íìù i ìë øåáò 3 rate-á ïøåúä äééôöä æåçà úà èåì < rate íà 32 1-á above20counter ìù åëøò úà ìãâä 321 above20counter ìù åëøò úà âöä 4 אם כך, למרות שהבעיה המוגדרת בסעיף א והבעיה המוגדרת בסעיף ב נראות דומות, הרי לפתרון סעיף א יש צורך במערך ואילו לפתרון סעיף ב אין צורך במערך מדוע יש בכך חשיבות? כידוע, בעת ביצוע תוכנית אשר יש בה שימוש במערך, מוקצה שטח זיכרון המספיק עבור כל איברי המערך מספר תאי הזיכרון המוקצים למערך הינו מרכיב משמעותי בקביעת גודל הזיכרון הכולל הדרוש לביצוע התוכנית כיוון שמשאבי הזיכרון של המחשב מוגבלים, נשתדל לפתח אלגוריתמים שגודל המקום הדרוש לביצועם הוא מצומצם במידת האפשר כלומר נשתדל לפתח אלגוריתמים יעילים עד כמה שניתן מבחינת מקום בזיכרון זאת בנוסף להקפדה על יעילות מבחינת זמן-ביצוע, כפי שהוצג בפרק 8 כאשר יש שני אלגוריתמים שונים לפתרון אותה בעיה, ובאחד מהם משתמשים במערך ובאחר אין משתמשים במערך, נאמר שהאלגוריתם האחר נעבור לפתרון סעיף ג ניתוח הבעיה בעזרת דוגמאות יעיל יותר מבחינת מקום בזיכרון גם בסעיף זה יש לפתח אלגוריתם הפותר את הבעיה שהוצגה בסעיף א אבל שלא כמו בסעיף א, נתון לנו מאפיין נוסף של הקלט: רשימת אחוזי הצפייה נתונה בסדר יורד הנה קלט לדוגמה העונה להגדרת הבעיה: ?? ממוצע הערכים הנתונים הוא 236 הערכים הגבוהים מן הממוצע הם 30 41, ו- 29 ניתן לראות כי מאחר שרשימת הערכים נתונה בסדר יורד, כל הערכים הגבוהים מן הממוצע נמצאים בתחילת הרשימה בדיוק כמו בסעיף א, את ההשוואה לממוצע ניתן לבצע רק לאחר חישוב הממוצע, כלומר רק לאחר קליטת כל הערכים האם ניתן לפתור סעיף זה ללא מערך? לא מאחר שההשוואה לממוצע יכולה להיעשות רק אחרי סיום הקלט, יש לשמור את כל הערכים הנקלטים, ולשם כך נחוץ מערך האם נוכל בכל זאת לשפר את הפתרון בשימוש במאפיין הקלט הנוסף? בעזרת דוגמת הקלט שניתחנו ראינו כי הערכים הגדולים מן הממוצע נמצאים כולם בתחילת הרשימה, ולכן גם יישמרו ראשונים בשלב שמירת הקלט לכן, בשלב ההשוואה לממוצע לא נצטרך לעבד שוב את כל ערכי הקלט, אלא רק את אלה המופיעים בהתחלה

29 לכן, במקום להשתמש בהוראה לביצוע-חוזר מספר פעמים ידוע מראש שתעבור על כל האיברים שנשמרו, נוכל להשתמש בהוראה לביצוע-חוזר-בתנאי התנאי יאפשר את המשך ביצוע הלולאה כל עוד האיבר התורן גדול מהממוצע ניתוח זה מראה כי הפתרון שניתן לא יהיה יעיל יותר מהפתרון של סעיף א מבחינת מקום בזיכרון, אבל יהיה בו שיפור מבחינת יעילות זמן: מניית הערכים הגדולים מהממוצע תעבור רק על חלק מהאיברים שנשמרו ולא על כולם פירוק הבעיה לתת-משימות בהתאם לניתוח שערכנו, נפרק את הבעיה באופן הבא: קליטת מספר התוכניות קליטת אחוזי הצפייה, שמירתם וצבירתם חישוב הממוצע מעבר על הערכים הגדולים מן הממוצע תוך כדי מנייתם הצגת ערך המונה בחירת משתנים numofprograms מטיפוס שלם, לשמירת מספר התוכניות rating מערך מטיפוס ממשי בן numofprograms איברים לשמירת אחוזי הצפייה הנתונים, והם יהיו מסודרים בו בסדר יורד sumofrating מטיפוס ממשי, צובר שישמור את סכום אחוזי הצפייה averageofrating מטיפוס ממשי, לשמירת ממוצע אחוזי הצפייה aboveaveragecounter מטיפוס שלם, מונה את אחוזי הצפייה הגבוהים מאחוז הצפייה הממוצע התוכנית המלאה /* (שלם חיובי) מספר של תוכניות קלט: נתונים בסדר יורד ורשימת אחוזי צפייה בתוכניות, מספר אחוזי הצפייה הגבוהים מאחוז הצפייה הממוצע פלט: */ import javautilscanner; public class AboveAverage public static void main (String[] args) Scanner in = new Scanner(Systemin); הגדרת משתנים // numofprograms; int מספר התוכניות // double[] rating; מערך אחוזי הצפייה // 0; = sumofrating double צובר אחוזי הצפייה // ; averageofrating double ממוצע אחוזי הצפייה // מונה הגבוהים מהממוצע // 0; = aboveaveragecounter int קלט וצבירה // Systemoutprint("Enter number of programs: "); numofprograms = innextint(); rating = new double[numofprograms];

30 for (int i = 0; i < numofprograms; i++) Systemoutprint("Enter rating percentage"); rating[i] = innextint(); sumofrating = sumofrating + rating[i]; } // for חישוב ממוצע // averageofrating = sumofrating / numofprograms; מניית הגבוהים מהממוצע // int i = 0; while(rating[i] > averageofrating) i++; aboveaveragecounter++; } // while פלט // Systemoutprintln("The rating of " + aboveaveragecounter + " programs is above average"); } // main } //class AboveAverage שימו העובדה שאחוזי הצפייה מסודרים בסדר יורד מאפשרת לסיים את לולאת ה- while מבלי לעבור על כל איברי המערך התנאי rating[i] > averageofrating משמש כתנאי כניסה ללולאה ולכן המנייה מסתיימת ברגע שנמצא אחוז צפייה שאינו גבוה מהממוצע אינה שאלה 1043 מדוע מובטח כי ההוראה לביצוע-חוזר-בתנאי, המונה את הערכים הגבוהים מהממוצע, לולאה אינסופית (במילים אחרות מדוע מובטח כי תנאי הכניסה יתקיים בשלב כלשהו)? 6 סוף פתרון בעיה מפתרון בעיה 6 למדנו לקח חשוב: יש לנצל עד כמה שניתן את מאפייני הקלט-פלט כדי לנסח אלגוריתם יעיל, הן מבחינת מקום בזיכרון והן מבחינת זמן-ביצוע ייתכנו שתי בעיות אלגוריתמיות הנראות דומות, לפחות במבט ראשון, ופתרונות יעילים עבורן נבדלים זה מזה הן מבחינת מקום והן מבחינת זמן בפרט, ייתכן שעבור פתרון בעיה אחת נחוץ מערך ועבור פתרון הבעיה האחרת לא נחוץ מערך שאלה 1044 נתונה רשימת קלט של 40 ציונים סמנו אם לביצוע כל אחד מהחישובים הבאים נחוץ מערך או לא: א מספר הציונים הגבוהים מ- 80 נחוץ / לא נחוץ ב מספר הציונים השווים לציון הראשון ברשימה נחוץ / לא נחוץ ג מספר הציונים הגבוהים מן הציון האחרון ברשימה נחוץ / לא נחוץ ד מספר הציונים הנמוכים מן הציון הלפני אחרון ברשימה נחוץ / לא נחוץ ה מספר הציונים הנמוכים מן הציון הראשון ומן הציון האחרון נחוץ / לא נחוץ ו מספר הציונים הנמוכים מממוצע הציונים נחוץ / לא נחוץ ז מספר הציונים הגבוהים מהממוצע של שני הציונים הראשונים נחוץ / לא נחוץ